home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  49.3 KB  |  1,770 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Quickdraw.p
  3.  
  4.      Contains:    QuickDraw Graphics Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Quickdraw;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __QUICKDRAW__}
  30. {$SETC __QUICKDRAW__ := 1}
  31.  
  32. {$I+}
  33. {$SETC QuickdrawIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __MIXEDMODE__}
  43. {$I MixedMode.p}
  44. {$ENDC}
  45.  
  46. {$IFC UNDEFINED __QUICKDRAWTEXT__}
  47. {$I QuickdrawText.p}
  48. {$ENDC}
  49.  
  50. {$PUSH}
  51. {$ALIGN MAC68K}
  52. {$LibExport+}
  53.  
  54. CONST
  55.     invalColReq                    = -1;                            {invalid color table request}
  56. { transfer modes }
  57.     srcCopy                        = 0;                            {the 16 transfer modes}
  58.     srcOr                        = 1;
  59.     srcXor                        = 2;
  60.     srcBic                        = 3;
  61.     notSrcCopy                    = 4;
  62.     notSrcOr                    = 5;
  63.     notSrcXor                    = 6;
  64.     notSrcBic                    = 7;
  65.     patCopy                        = 8;
  66.     patOr                        = 9;
  67.     patXor                        = 10;
  68.     patBic                        = 11;
  69.     notPatCopy                    = 12;
  70.     notPatOr                    = 13;
  71.     notPatXor                    = 14;
  72.     notPatBic                    = 15;
  73. { Special Text Transfer Mode }
  74.     grayishTextOr                = 49;
  75.     hilitetransfermode            = 50;
  76. { Arithmetic transfer modes }
  77.     blend                        = 32;
  78.     addPin                        = 33;
  79.  
  80.     addOver                        = 34;
  81.     subPin                        = 35;
  82.     addMax                        = 37;
  83.     adMax                        = 37;
  84.     subOver                        = 38;
  85.     adMin                        = 39;
  86.     ditherCopy                    = 64;
  87. { Transparent mode constant }
  88.     transparent                    = 36;
  89.     italicBit                    = 1;
  90.     ulineBit                    = 2;
  91.     outlineBit                    = 3;
  92.     shadowBit                    = 4;
  93.     condenseBit                    = 5;
  94.     extendBit                    = 6;
  95. { QuickDraw color separation constants }
  96.     normalBit                    = 0;                            {normal screen mapping}
  97.     inverseBit                    = 1;                            {inverse screen mapping}
  98.     redBit                        = 4;                            {RGB additive mapping}
  99.     greenBit                    = 3;
  100.     blueBit                        = 2;
  101.     cyanBit                        = 8;                            {CMYBk subtractive mapping}
  102.     magentaBit                    = 7;
  103.     yellowBit                    = 6;
  104.     blackBit                    = 5;
  105.     blackColor                    = 33;                            {colors expressed in these mappings}
  106.     whiteColor                    = 30;
  107.     redColor                    = 205;
  108.  
  109.     greenColor                    = 341;
  110.     blueColor                    = 409;
  111.     cyanColor                    = 273;
  112.     magentaColor                = 137;
  113.     yellowColor                    = 69;
  114.     picLParen                    = 0;                            {standard picture comments}
  115.     picRParen                    = 1;
  116.     clutType                    = 0;                            {0 if lookup table}
  117.     fixedType                    = 1;                            {1 if fixed table}
  118.     directType                    = 2;                            {2 if direct values}
  119.     gdDevType                    = 0;                            {0 = monochrome 1 = color}
  120.  
  121.     roundedDevice                = 5;                            { 1 if device has been “rounded” into the GrayRgn }
  122.     hasAuxMenuBar                = 6;                            { 1 if device has an aux menu bar on it }
  123.     burstDevice                    = 7;
  124.     ext32Device                    = 8;
  125.     ramInit                        = 10;                            {1 if initialized from 'scrn' resource}
  126.     mainScreen                    = 11;                            { 1 if main screen }
  127.     allInit                        = 12;                            { 1 if all devices initialized }
  128.     screenDevice                = 13;                            {1 if screen device [not used]}
  129.     noDriver                    = 14;                            { 1 if no driver for this GDevice }
  130.     screenActive                = 15;                            {1 if in use}
  131.     hiliteBit                    = 7;                            {flag bit in HiliteMode (lowMem flag)}
  132.     pHiliteBit                    = 0;                            {flag bit in HiliteMode used with BitClr procedure}
  133.     defQDColors                    = 127;                            {resource ID of clut for default QDColors}
  134. { pixel type }
  135.     RGBDirect                    = 16;                            { 16 & 32 bits/pixel pixelType value }
  136. { pmVersion values }
  137.     baseAddr32                    = 4;                            {pixmap base address is 32-bit address}
  138.  
  139.     frame                        = 0;
  140.     paint                        = 1;
  141.     erase                        = 2;
  142.     invert                        = 3;
  143.     fill                        = 4;
  144.  
  145.     
  146. TYPE
  147.     GrafVerb = SInt8;
  148.  
  149.  
  150. CONST
  151.     chunky                        = 0;
  152.     chunkyPlanar                = 1;
  153.     planar                        = 2;
  154.  
  155.     
  156. TYPE
  157.     PixelType = SInt8;
  158.  
  159.     Bits16 = ARRAY [0..15] OF INTEGER;
  160.  
  161. {**************   IMPORTANT NOTE REGARDING Pattern  **************************************
  162.    Patterns were originally defined as:
  163.    
  164.         C:             typedef unsigned char Pattern[8];
  165.         Pascal:        Pattern = PACKED ARRAY [0..7] OF 0..255;
  166.         
  167.    The old array defintion of Pattern would cause 68000 based CPU's to crash in certain circum-
  168.    stances. The new struct definition is safe, but may require source code changes to compile.
  169.    Read the details in TechNote "Platforms & Tools" #PT 38.
  170.     
  171. ********************************************************************************************}
  172.     Pattern = RECORD
  173.         pat:                    PACKED ARRAY [0..7] OF SInt8; (* UInt8 *)
  174.     END;
  175.  
  176. {
  177.  ConstPatternParam is now longer needed.  It was first created when Pattern was an array.
  178.  Now that Pattern is a struct, it is more straight forward just add the "const" qualifier
  179.  on the parameter type (e.g. "const Pattern * pat" instead of "ConstPatternParam pat").
  180. }
  181.     PatPtr = ^Pattern;
  182.  
  183.     PatHandle = ^PatPtr;
  184.  
  185.     QDByte = SignedByte;
  186.  
  187.     QDPtr = Ptr;
  188.  
  189.     QDHandle = Handle;
  190.  
  191.     QDErr = INTEGER;
  192.  
  193.  
  194. CONST
  195.     singleDevicesBit            = 0;
  196.     dontMatchSeedsBit            = 1;
  197.     allDevicesBit                = 2;
  198.  
  199.     singleDevices                = 1 * (2**(singleDevicesBit));
  200.     dontMatchSeeds                = 1 * (2**(dontMatchSeedsBit));
  201.     allDevices                    = 1 * (2**(allDevicesBit));
  202.  
  203.     
  204. TYPE
  205.     DeviceLoopFlags = LONGINT;
  206.  
  207.     BitMap = RECORD
  208.         baseAddr:                Ptr;
  209.         rowBytes:                INTEGER;
  210.         bounds:                    Rect;
  211.     END;
  212.  
  213.     BitMapPtr = ^BitMap;
  214.     BitMapHandle = ^BitMapPtr;
  215.  
  216.     Cursor = RECORD
  217.         data:                    Bits16;
  218.         mask:                    Bits16;
  219.         hotSpot:                Point;
  220.     END;
  221.  
  222.     CursPtr = ^Cursor;
  223.     CursHandle = ^CursPtr;
  224.  
  225.     PenState = RECORD
  226.         pnLoc:                    Point;
  227.         pnSize:                    Point;
  228.         pnMode:                    INTEGER;
  229.         pnPat:                    Pattern;
  230.     END;
  231.  
  232.     Region = RECORD
  233.         rgnSize:                INTEGER;                                {size in bytes}
  234.         rgnBBox:                Rect;                                    {enclosing rectangle}
  235.     END;
  236.  
  237.     RgnPtr = ^Region;
  238.     RgnHandle = ^RgnPtr;
  239.  
  240.     Picture = RECORD
  241.         picSize:                INTEGER;
  242.         picFrame:                Rect;
  243.     END;
  244.  
  245.     PicPtr = ^Picture;
  246.     PicHandle = ^PicPtr;
  247.  
  248.     Polygon = RECORD
  249.         polySize:                INTEGER;
  250.         polyBBox:                Rect;
  251.         polyPoints:                ARRAY [0..0] OF Point;
  252.     END;
  253.  
  254.     PolyPtr = ^Polygon;
  255.     PolyHandle = ^PolyPtr;
  256.  
  257.     QDTextProcPtr = ProcPtr;  { PROCEDURE QDText(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point); }
  258.     QDLineProcPtr = ProcPtr;  { PROCEDURE QDLine(newPt: Point); }
  259.     QDRectProcPtr = ProcPtr;  { PROCEDURE QDRect(verb: ByteParameter; VAR r: Rect); }
  260.     QDRRectProcPtr = ProcPtr;  { PROCEDURE QDRRect(verb: ByteParameter; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER); }
  261.     QDOvalProcPtr = ProcPtr;  { PROCEDURE QDOval(verb: ByteParameter; VAR r: Rect); }
  262.     QDArcProcPtr = ProcPtr;  { PROCEDURE QDArc(verb: ByteParameter; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER); }
  263.     QDPolyProcPtr = ProcPtr;  { PROCEDURE QDPoly(verb: ByteParameter; poly: PolyHandle); }
  264.     QDRgnProcPtr = ProcPtr;  { PROCEDURE QDRgn(verb: ByteParameter; rgn: RgnHandle); }
  265.     QDBitsProcPtr = ProcPtr;  { PROCEDURE QDBits(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle); }
  266.     QDCommentProcPtr = ProcPtr;  { PROCEDURE QDComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle); }
  267.     QDTxMeasProcPtr = ProcPtr;  { FUNCTION QDTxMeas(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER; }
  268.     QDGetPicProcPtr = ProcPtr;  { PROCEDURE QDGetPic(dataPtr: Ptr; byteCount: INTEGER); }
  269.     QDPutPicProcPtr = ProcPtr;  { PROCEDURE QDPutPic(dataPtr: Ptr; byteCount: INTEGER); }
  270.     QDOpcodeProcPtr = ProcPtr;  { PROCEDURE QDOpcode(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER); }
  271.     QDJShieldCursorProcPtr = ProcPtr;  { PROCEDURE QDJShieldCursor(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER); }
  272.     QDTextUPP = UniversalProcPtr;
  273.     QDLineUPP = UniversalProcPtr;
  274.     QDRectUPP = UniversalProcPtr;
  275.     QDRRectUPP = UniversalProcPtr;
  276.     QDOvalUPP = UniversalProcPtr;
  277.     QDArcUPP = UniversalProcPtr;
  278.     QDPolyUPP = UniversalProcPtr;
  279.     QDRgnUPP = UniversalProcPtr;
  280.     QDBitsUPP = UniversalProcPtr;
  281.     QDCommentUPP = UniversalProcPtr;
  282.     QDTxMeasUPP = UniversalProcPtr;
  283.     QDGetPicUPP = UniversalProcPtr;
  284.     QDPutPicUPP = UniversalProcPtr;
  285.     QDOpcodeUPP = UniversalProcPtr;
  286.     QDJShieldCursorUPP = UniversalProcPtr;
  287.  
  288.     QDProcs = RECORD
  289.         textProc:                QDTextUPP;
  290.         lineProc:                QDLineUPP;
  291.         rectProc:                QDRectUPP;
  292.         rRectProc:                QDRRectUPP;
  293.         ovalProc:                QDOvalUPP;
  294.         arcProc:                QDArcUPP;
  295.         polyProc:                QDPolyUPP;
  296.         rgnProc:                QDRgnUPP;
  297.         bitsProc:                QDBitsUPP;
  298.         commentProc:            QDCommentUPP;
  299.         txMeasProc:                QDTxMeasUPP;
  300.         getPicProc:                QDGetPicUPP;
  301.         putPicProc:                QDPutPicUPP;
  302.     END;
  303.  
  304.     QDProcsPtr = ^QDProcs;
  305.  
  306. CONST
  307.     uppQDTextProcInfo = $00003F80; { PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param); }
  308.     uppQDLineProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  309.     uppQDRectProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  310.     uppQDRRectProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  311.     uppQDOvalProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  312.     uppQDArcProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  313.     uppQDPolyProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  314.     uppQDRgnProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  315.     uppQDBitsProcInfo = $0000EFC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  316.     uppQDCommentProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  317.     uppQDTxMeasProcInfo = $0000FFA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  318.     uppQDGetPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  319.     uppQDPutPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  320.     uppQDOpcodeProcInfo = $00002BC0; { PROCEDURE (4 byte param, 4 byte param, 2 byte param, 2 byte param); }
  321.     uppQDJShieldCursorProcInfo = $00002A80; { PROCEDURE (2 byte param, 2 byte param, 2 byte param, 2 byte param); }
  322.  
  323. FUNCTION NewQDTextProc(userRoutine: QDTextProcPtr): QDTextUPP;
  324.     {$IFC NOT GENERATINGCFM }
  325.     INLINE $2E9F;
  326.     {$ENDC}
  327.  
  328. FUNCTION NewQDLineProc(userRoutine: QDLineProcPtr): QDLineUPP;
  329.     {$IFC NOT GENERATINGCFM }
  330.     INLINE $2E9F;
  331.     {$ENDC}
  332.  
  333. FUNCTION NewQDRectProc(userRoutine: QDRectProcPtr): QDRectUPP;
  334.     {$IFC NOT GENERATINGCFM }
  335.     INLINE $2E9F;
  336.     {$ENDC}
  337.  
  338. FUNCTION NewQDRRectProc(userRoutine: QDRRectProcPtr): QDRRectUPP;
  339.     {$IFC NOT GENERATINGCFM }
  340.     INLINE $2E9F;
  341.     {$ENDC}
  342.  
  343. FUNCTION NewQDOvalProc(userRoutine: QDOvalProcPtr): QDOvalUPP;
  344.     {$IFC NOT GENERATINGCFM }
  345.     INLINE $2E9F;
  346.     {$ENDC}
  347.  
  348. FUNCTION NewQDArcProc(userRoutine: QDArcProcPtr): QDArcUPP;
  349.     {$IFC NOT GENERATINGCFM }
  350.     INLINE $2E9F;
  351.     {$ENDC}
  352.  
  353. FUNCTION NewQDPolyProc(userRoutine: QDPolyProcPtr): QDPolyUPP;
  354.     {$IFC NOT GENERATINGCFM }
  355.     INLINE $2E9F;
  356.     {$ENDC}
  357.  
  358. FUNCTION NewQDRgnProc(userRoutine: QDRgnProcPtr): QDRgnUPP;
  359.     {$IFC NOT GENERATINGCFM }
  360.     INLINE $2E9F;
  361.     {$ENDC}
  362.  
  363. FUNCTION NewQDBitsProc(userRoutine: QDBitsProcPtr): QDBitsUPP;
  364.     {$IFC NOT GENERATINGCFM }
  365.     INLINE $2E9F;
  366.     {$ENDC}
  367.  
  368. FUNCTION NewQDCommentProc(userRoutine: QDCommentProcPtr): QDCommentUPP;
  369.     {$IFC NOT GENERATINGCFM }
  370.     INLINE $2E9F;
  371.     {$ENDC}
  372.  
  373. FUNCTION NewQDTxMeasProc(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  374.     {$IFC NOT GENERATINGCFM }
  375.     INLINE $2E9F;
  376.     {$ENDC}
  377.  
  378. FUNCTION NewQDGetPicProc(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  379.     {$IFC NOT GENERATINGCFM }
  380.     INLINE $2E9F;
  381.     {$ENDC}
  382.  
  383. FUNCTION NewQDPutPicProc(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  384.     {$IFC NOT GENERATINGCFM }
  385.     INLINE $2E9F;
  386.     {$ENDC}
  387.  
  388. FUNCTION NewQDOpcodeProc(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  389.     {$IFC NOT GENERATINGCFM }
  390.     INLINE $2E9F;
  391.     {$ENDC}
  392.  
  393. FUNCTION NewQDJShieldCursorProc(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  394.     {$IFC NOT GENERATINGCFM }
  395.     INLINE $2E9F;
  396.     {$ENDC}
  397.  
  398. PROCEDURE CallQDTextProc(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point; userRoutine: QDTextUPP);
  399.     {$IFC NOT GENERATINGCFM}
  400.     INLINE $205F, $4E90;
  401.     {$ENDC}
  402.  
  403. PROCEDURE CallQDLineProc(newPt: Point; userRoutine: QDLineUPP);
  404.     {$IFC NOT GENERATINGCFM}
  405.     INLINE $205F, $4E90;
  406.     {$ENDC}
  407.  
  408. PROCEDURE CallQDRectProc(verb: ByteParameter; VAR r: Rect; userRoutine: QDRectUPP);
  409.     {$IFC NOT GENERATINGCFM}
  410.     INLINE $205F, $4E90;
  411.     {$ENDC}
  412.  
  413. PROCEDURE CallQDRRectProc(verb: ByteParameter; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  414.     {$IFC NOT GENERATINGCFM}
  415.     INLINE $205F, $4E90;
  416.     {$ENDC}
  417.  
  418. PROCEDURE CallQDOvalProc(verb: ByteParameter; VAR r: Rect; userRoutine: QDOvalUPP);
  419.     {$IFC NOT GENERATINGCFM}
  420.     INLINE $205F, $4E90;
  421.     {$ENDC}
  422.  
  423. PROCEDURE CallQDArcProc(verb: ByteParameter; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  424.     {$IFC NOT GENERATINGCFM}
  425.     INLINE $205F, $4E90;
  426.     {$ENDC}
  427.  
  428. PROCEDURE CallQDPolyProc(verb: ByteParameter; poly: PolyHandle; userRoutine: QDPolyUPP);
  429.     {$IFC NOT GENERATINGCFM}
  430.     INLINE $205F, $4E90;
  431.     {$ENDC}
  432.  
  433. PROCEDURE CallQDRgnProc(verb: ByteParameter; rgn: RgnHandle; userRoutine: QDRgnUPP);
  434.     {$IFC NOT GENERATINGCFM}
  435.     INLINE $205F, $4E90;
  436.     {$ENDC}
  437.  
  438. PROCEDURE CallQDBitsProc(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  439.     {$IFC NOT GENERATINGCFM}
  440.     INLINE $205F, $4E90;
  441.     {$ENDC}
  442.  
  443. PROCEDURE CallQDCommentProc(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle; userRoutine: QDCommentUPP);
  444.     {$IFC NOT GENERATINGCFM}
  445.     INLINE $205F, $4E90;
  446.     {$ENDC}
  447.  
  448. FUNCTION CallQDTxMeasProc(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  449.     {$IFC NOT GENERATINGCFM}
  450.     INLINE $205F, $4E90;
  451.     {$ENDC}
  452.  
  453. PROCEDURE CallQDGetPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  454.     {$IFC NOT GENERATINGCFM}
  455.     INLINE $205F, $4E90;
  456.     {$ENDC}
  457.  
  458. PROCEDURE CallQDPutPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  459.     {$IFC NOT GENERATINGCFM}
  460.     INLINE $205F, $4E90;
  461.     {$ENDC}
  462.  
  463. PROCEDURE CallQDOpcodeProc(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  464.     {$IFC NOT GENERATINGCFM}
  465.     INLINE $205F, $4E90;
  466.     {$ENDC}
  467.  
  468. PROCEDURE CallQDJShieldCursorProc(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  469.     {$IFC NOT GENERATINGCFM}
  470.     INLINE $205F, $4E90;
  471.     {$ENDC}
  472.  
  473. TYPE
  474.     GrafPort = RECORD
  475.         device:                    INTEGER;
  476.         portBits:                BitMap;
  477.         portRect:                Rect;
  478.         visRgn:                    RgnHandle;
  479.         clipRgn:                RgnHandle;
  480.         bkPat:                    Pattern;
  481.         fillPat:                Pattern;
  482.         pnLoc:                    Point;
  483.         pnSize:                    Point;
  484.         pnMode:                    INTEGER;
  485.         pnPat:                    Pattern;
  486.         pnVis:                    INTEGER;
  487.         txFont:                    INTEGER;
  488.         txFace:                    Style;                                    {txFace is unpacked byte but push as short}
  489.         txMode:                    INTEGER;
  490.         txSize:                    INTEGER;
  491.         spExtra:                Fixed;
  492.         fgColor:                LONGINT;
  493.         bkColor:                LONGINT;
  494.         colrBit:                INTEGER;
  495.         patStretch:                INTEGER;
  496.         picSave:                Handle;
  497.         rgnSave:                Handle;
  498.         polySave:                Handle;
  499.         grafProcs:                QDProcsPtr;
  500.     END;
  501.  
  502.     GrafPtr = ^GrafPort;
  503.  
  504. {
  505.  *    This set of definitions "belongs" in Windows.
  506.  *    But, there is a circularity in the headers where Windows includes Controls and
  507.  *    Controls includes Windows. To break the circle, the information
  508.  *    needed by Controls is moved from Windows to Quickdraw.
  509.  }
  510.     WindowPtr = GrafPtr;
  511.  
  512. {
  513.     Set STRICT_WINDOWS to 1 to make sure your code 
  514.     doesn't access the window record directly
  515. }
  516. {$IFC UNDEFINED STRICT_WINDOWS }
  517. {$SETC STRICT_WINDOWS := 0}
  518. {$ENDC}
  519. {$IFC STRICT_WINDOWS }
  520.     WindowRef = Ptr;
  521.  
  522. {$ELSEC}
  523.     WindowRef = WindowPtr;
  524.  
  525. {$ENDC}
  526.     DragConstraint = UInt16;
  527.  
  528.  
  529. CONST
  530.     kNoConstraint                = 0;
  531.     kVerticalConstraint            = 1;
  532.     kHorizontalConstraint        = 2;
  533.  
  534. {
  535.  *    Here ends the list of things that "belong" in Windows.
  536.  }
  537.  
  538. TYPE
  539.     RGBColor = RECORD
  540.         red:                    INTEGER;                                {magnitude of red component}
  541.         green:                    INTEGER;                                {magnitude of green component}
  542.         blue:                    INTEGER;                                {magnitude of blue component}
  543.     END;
  544.  
  545.     RGBColorPtr = ^RGBColor;
  546.     RGBColorHdl = ^RGBColorPtr;
  547.  
  548.     DragGrayRgnProcPtr = ProcPtr;  { PROCEDURE DragGrayRgn; }
  549.     ColorSearchProcPtr = ProcPtr;  { FUNCTION ColorSearch(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN; }
  550.     ColorComplementProcPtr = ProcPtr;  { FUNCTION ColorComplement(VAR rgb: RGBColor): BOOLEAN; }
  551.     DragGrayRgnUPP = UniversalProcPtr;
  552.     ColorSearchUPP = UniversalProcPtr;
  553.     ColorComplementUPP = UniversalProcPtr;
  554.  
  555. CONST
  556.     uppDragGrayRgnProcInfo = $00000000; { PROCEDURE ; }
  557.     uppColorSearchProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  558.     uppColorComplementProcInfo = $000000D0; { FUNCTION (4 byte param): 1 byte result; }
  559.  
  560. FUNCTION NewDragGrayRgnProc(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  561.     {$IFC NOT GENERATINGCFM }
  562.     INLINE $2E9F;
  563.     {$ENDC}
  564.  
  565. FUNCTION NewColorSearchProc(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  566.     {$IFC NOT GENERATINGCFM }
  567.     INLINE $2E9F;
  568.     {$ENDC}
  569.  
  570. FUNCTION NewColorComplementProc(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  571.     {$IFC NOT GENERATINGCFM }
  572.     INLINE $2E9F;
  573.     {$ENDC}
  574.  
  575. PROCEDURE CallDragGrayRgnProc(userRoutine: DragGrayRgnUPP);
  576.     {$IFC NOT GENERATINGCFM}
  577.     INLINE $205F, $4E90;
  578.     {$ENDC}
  579.  
  580. FUNCTION CallColorSearchProc(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  581.     {$IFC NOT GENERATINGCFM}
  582.     INLINE $205F, $4E90;
  583.     {$ENDC}
  584.  
  585. FUNCTION CallColorComplementProc(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  586.     {$IFC NOT GENERATINGCFM}
  587.     INLINE $205F, $4E90;
  588.     {$ENDC}
  589.  
  590. TYPE
  591.     ColorSpec = RECORD
  592.         value:                    INTEGER;                                {index or other value}
  593.         rgb:                    RGBColor;                                {true color}
  594.     END;
  595.  
  596.     ColorSpecPtr = ^ColorSpec;
  597.  
  598.     CSpecArray = ARRAY [0..0] OF ColorSpec;
  599.  
  600.     xColorSpec = RECORD
  601.         value:                    INTEGER;                                {index or other value}
  602.         rgb:                    RGBColor;                                {true color}
  603.         xalpha:                    INTEGER;
  604.     END;
  605.  
  606.     xColorSpecPtr = ^xColorSpec;
  607.  
  608.     xCSpecArray = ARRAY [0..0] OF xColorSpec;
  609.  
  610.     ColorTable = RECORD
  611.         ctSeed:                    LONGINT;                                {unique identifier for table}
  612.         ctFlags:                INTEGER;                                {high bit: 0 = PixMap; 1 = device}
  613.         ctSize:                    INTEGER;                                {number of entries in CTTable}
  614.         ctTable:                CSpecArray;                                {array [0..0] of ColorSpec}
  615.     END;
  616.  
  617.     CTabPtr = ^ColorTable;
  618.     CTabHandle = ^CTabPtr;
  619.  
  620.     MatchRec = RECORD
  621.         red:                    INTEGER;
  622.         green:                    INTEGER;
  623.         blue:                    INTEGER;
  624.         matchData:                LONGINT;
  625.     END;
  626.  
  627.     PixMap = RECORD
  628.         baseAddr:                Ptr;                                    {pointer to pixels}
  629.         rowBytes:                INTEGER;                                {offset to next line}
  630.         bounds:                    Rect;                                    {encloses bitmap}
  631.         pmVersion:                INTEGER;                                {pixMap version number}
  632.         packType:                INTEGER;                                {defines packing format}
  633.         packSize:                LONGINT;                                {length of pixel data}
  634.         hRes:                    Fixed;                                    {horiz. resolution (ppi)}
  635.         vRes:                    Fixed;                                    {vert. resolution (ppi)}
  636.         pixelType:                INTEGER;                                {defines pixel type}
  637.         pixelSize:                INTEGER;                                {# bits in pixel}
  638.         cmpCount:                INTEGER;                                {# components in pixel}
  639.         cmpSize:                INTEGER;                                {# bits per component}
  640.         planeBytes:                LONGINT;                                {offset to next plane}
  641.         pmTable:                CTabHandle;                                {color map for this pixMap}
  642.         pmReserved:                LONGINT;                                {for future use. MUST BE 0}
  643.     END;
  644.  
  645.     PixMapPtr = ^PixMap;
  646.     PixMapHandle = ^PixMapPtr;
  647.  
  648.     PixPat = RECORD
  649.         patType:                INTEGER;                                {type of pattern}
  650.         patMap:                    PixMapHandle;                            {the pattern's pixMap}
  651.         patData:                Handle;                                    {pixmap's data}
  652.         patXData:                Handle;                                    {expanded Pattern data}
  653.         patXValid:                INTEGER;                                {flags whether expanded Pattern valid}
  654.         patXMap:                Handle;                                    {Handle to expanded Pattern data}
  655.         pat1Data:                Pattern;                                {old-Style pattern/RGB color}
  656.     END;
  657.  
  658.     PixPatPtr = ^PixPat;
  659.     PixPatHandle = ^PixPatPtr;
  660.  
  661.     CCrsr = RECORD
  662.         crsrType:                INTEGER;                                {type of cursor}
  663.         crsrMap:                PixMapHandle;                            {the cursor's pixmap}
  664.         crsrData:                Handle;                                    {cursor's data}
  665.         crsrXData:                Handle;                                    {expanded cursor data}
  666.         crsrXValid:                INTEGER;                                {depth of expanded data (0 if none)}
  667.         crsrXHandle:            Handle;                                    {future use}
  668.         crsr1Data:                Bits16;                                    {one-bit cursor}
  669.         crsrMask:                Bits16;                                    {cursor's mask}
  670.         crsrHotSpot:            Point;                                    {cursor's hotspot}
  671.         crsrXTable:                LONGINT;                                {private}
  672.         crsrID:                    LONGINT;                                {private}
  673.     END;
  674.  
  675.     CCrsrPtr = ^CCrsr;
  676.     CCrsrHandle = ^CCrsrPtr;
  677.  
  678. {$IFC OLDROUTINELOCATIONS }
  679.     CIcon = RECORD
  680.         iconPMap:                PixMap;                                    {the icon's pixMap}
  681.         iconMask:                BitMap;                                    {the icon's mask}
  682.         iconBMap:                BitMap;                                    {the icon's bitMap}
  683.         iconData:                Handle;                                    {the icon's data}
  684.         iconMaskData:            ARRAY [0..0] OF INTEGER;                {icon's mask and BitMap data}
  685.     END;
  686.  
  687.     CIconPtr = ^CIcon;
  688.     CIconHandle = ^CIconPtr;
  689.  
  690. {$ENDC}
  691.     GammaTbl = RECORD
  692.         gVersion:                INTEGER;                                {gamma version number}
  693.         gType:                    INTEGER;                                {gamma data type}
  694.         gFormulaSize:            INTEGER;                                {Formula data size}
  695.         gChanCnt:                INTEGER;                                {number of channels of data}
  696.         gDataCnt:                INTEGER;                                {number of values/channel}
  697.         gDataWidth:                INTEGER;                                {bits/corrected value (data packed to next larger byte size)}
  698.         gFormulaData:            ARRAY [0..0] OF INTEGER;                {data for formulas followed by gamma values}
  699.     END;
  700.  
  701.     GammaTblPtr = ^GammaTbl;
  702.     GammaTblHandle = ^GammaTblPtr;
  703.  
  704.     ITab = RECORD
  705.         iTabSeed:                LONGINT;                                {copy of CTSeed from source CTable}
  706.         iTabRes:                INTEGER;                                {bits/channel resolution of iTable}
  707.         iTTable:                ARRAY [0..0] OF SInt8; (* Byte *)        {byte colortable index values}
  708.     END;
  709.  
  710.     ITabPtr = ^ITab;
  711.     ITabHandle = ^ITabPtr;
  712.  
  713.     SProcRec = RECORD
  714.         nxtSrch:                Handle;                                    {SProcHndl Handle to next SProcRec}
  715.         srchProc:                ColorSearchUPP;                            {search procedure proc ptr}
  716.     END;
  717.  
  718.     SProcPtr = ^SProcRec;
  719.     SProcHndl = ^SProcPtr;
  720.  
  721.     CProcRec = RECORD
  722.         nxtComp:                Handle;                                    {CProcHndl Handle to next CProcRec}
  723.         compProc:                ColorComplementUPP;                        {complement procedure proc ptr}
  724.     END;
  725.  
  726.     CProcPtr = ^CProcRec;
  727.     CProcHndl = ^CProcPtr;
  728.  
  729.     GDevice = RECORD
  730.         gdRefNum:                INTEGER;                                {driver's unit number}
  731.         gdID:                    INTEGER;                                {client ID for search procs}
  732.         gdType:                    INTEGER;                                {fixed/CLUT/direct}
  733.         gdITable:                ITabHandle;                                {Handle to inverse lookup table}
  734.         gdResPref:                INTEGER;                                {preferred resolution of GDITable}
  735.         gdSearchProc:            SProcHndl;                                {search proc list head}
  736.         gdCompProc:                CProcHndl;                                {complement proc list}
  737.         gdFlags:                INTEGER;                                {grafDevice flags word}
  738.         gdPMap:                    PixMapHandle;                            {describing pixMap}
  739.         gdRefCon:                LONGINT;                                {reference value}
  740.         gdNextGD:                Handle;                                    {GDHandle Handle of next gDevice}
  741.         gdRect:                    Rect;                                    { device's bounds in global coordinates}
  742.         gdMode:                    LONGINT;                                {device's current mode}
  743.         gdCCBytes:                INTEGER;                                {depth of expanded cursor data}
  744.         gdCCDepth:                INTEGER;                                {depth of expanded cursor data}
  745.         gdCCXData:                Handle;                                    {Handle to cursor's expanded data}
  746.         gdCCXMask:                Handle;                                    {Handle to cursor's expanded mask}
  747.         gdReserved:                LONGINT;                                {future use. MUST BE 0}
  748.     END;
  749.  
  750.     GDPtr = ^GDevice;
  751.     GDHandle = ^GDPtr;
  752.  
  753.     GrafVars = RECORD
  754.         rgbOpColor:                RGBColor;                                {color for addPin  subPin and average}
  755.         rgbHiliteColor:            RGBColor;                                {color for hiliting}
  756.         pmFgColor:                Handle;                                    {palette Handle for foreground color}
  757.         pmFgIndex:                INTEGER;                                {index value for foreground}
  758.         pmBkColor:                Handle;                                    {palette Handle for background color}
  759.         pmBkIndex:                INTEGER;                                {index value for background}
  760.         pmFlags:                INTEGER;                                {flags for Palette Manager}
  761.     END;
  762.  
  763.     GVarPtr = ^GrafVars;
  764.     GVarHandle = ^GVarPtr;
  765.  
  766.     CQDProcs = RECORD
  767.         textProc:                QDTextUPP;
  768.         lineProc:                QDLineUPP;
  769.         rectProc:                QDRectUPP;
  770.         rRectProc:                QDRRectUPP;
  771.         ovalProc:                QDOvalUPP;
  772.         arcProc:                QDArcUPP;
  773.         polyProc:                QDPolyUPP;
  774.         rgnProc:                QDRgnUPP;
  775.         bitsProc:                QDBitsUPP;
  776.         commentProc:            QDCommentUPP;
  777.         txMeasProc:                QDTxMeasUPP;
  778.         getPicProc:                QDGetPicUPP;
  779.         putPicProc:                QDPutPicUPP;
  780.         opcodeProc:                QDOpcodeUPP;                            {fields added to QDProcs}
  781.         newProc1:                UniversalProcPtr;
  782.         newProc2:                UniversalProcPtr;
  783.         newProc3:                UniversalProcPtr;
  784.         newProc4:                UniversalProcPtr;
  785.         newProc5:                UniversalProcPtr;
  786.         newProc6:                UniversalProcPtr;
  787.     END;
  788.  
  789.     CQDProcsPtr = ^CQDProcs;
  790.  
  791.     CGrafPort = RECORD
  792.         device:                    INTEGER;
  793.         portPixMap:                PixMapHandle;                            {port's pixel map}
  794.         portVersion:            INTEGER;                                {high 2 bits always set}
  795.         grafVars:                Handle;                                    {Handle to more fields}
  796.         chExtra:                INTEGER;                                {character extra}
  797.         pnLocHFrac:                INTEGER;                                {pen fraction}
  798.         portRect:                Rect;
  799.         visRgn:                    RgnHandle;
  800.         clipRgn:                RgnHandle;
  801.         bkPixPat:                PixPatHandle;                            {background pattern}
  802.         rgbFgColor:                RGBColor;                                {RGB components of fg}
  803.         rgbBkColor:                RGBColor;                                {RGB components of bk}
  804.         pnLoc:                    Point;
  805.         pnSize:                    Point;
  806.         pnMode:                    INTEGER;
  807.         pnPixPat:                PixPatHandle;                            {pen's pattern}
  808.         fillPixPat:                PixPatHandle;                            {fill pattern}
  809.         pnVis:                    INTEGER;
  810.         txFont:                    INTEGER;
  811.         txFace:                    Style;                                    {txFace is unpacked byte  push as short}
  812.         txMode:                    INTEGER;
  813.         txSize:                    INTEGER;
  814.         spExtra:                Fixed;
  815.         fgColor:                LONGINT;
  816.         bkColor:                LONGINT;
  817.         colrBit:                INTEGER;
  818.         patStretch:                INTEGER;
  819.         picSave:                Handle;
  820.         rgnSave:                Handle;
  821.         polySave:                Handle;
  822.         grafProcs:                CQDProcsPtr;
  823.     END;
  824.  
  825.     CGrafPtr = ^CGrafPort;
  826.  
  827.     CWindowPtr = CGrafPtr;
  828.  
  829.     ReqListRec = RECORD
  830.         reqLSize:                INTEGER;                                {request list size}
  831.         reqLData:                ARRAY [0..0] OF INTEGER;                {request list data}
  832.     END;
  833.  
  834.     OpenCPicParams = RECORD
  835.         srcRect:                Rect;
  836.         hRes:                    Fixed;
  837.         vRes:                    Fixed;
  838.         version:                INTEGER;
  839.         reserved1:                INTEGER;
  840.         reserved2:                LONGINT;
  841.     END;
  842.  
  843.     CursorImageRec = RECORD
  844.         majorVersion:            UInt16;
  845.         minorVersion:            UInt16;
  846.         cursorPixMap:            PixMapHandle;
  847.         cursorBitMask:            BitMapHandle;
  848.     END;
  849.  
  850.     CursorImagePtr = ^CursorImageRec;
  851.  
  852.     DeviceLoopDrawingProcPtr = ProcPtr;  { PROCEDURE DeviceLoopDrawing(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT); }
  853.     DeviceLoopDrawingUPP = UniversalProcPtr;
  854.  
  855. CONST
  856.     uppDeviceLoopDrawingProcInfo = $00003E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param, 4 byte param); }
  857.  
  858. FUNCTION NewDeviceLoopDrawingProc(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  859.     {$IFC NOT GENERATINGCFM }
  860.     INLINE $2E9F;
  861.     {$ENDC}
  862.  
  863. PROCEDURE CallDeviceLoopDrawingProc(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  864.     {$IFC NOT GENERATINGCFM}
  865.     INLINE $205F, $4E90;
  866.     {$ENDC}
  867.  
  868. TYPE
  869.     QDGlobals = RECORD
  870.         privates:                PACKED ARRAY [0..75] OF CHAR;
  871.         randSeed:                LONGINT;
  872.         screenBits:                BitMap;
  873.         arrow:                    Cursor;
  874.         dkGray:                    Pattern;
  875.         ltGray:                    Pattern;
  876.         gray:                    Pattern;
  877.         black:                    Pattern;
  878.         white:                    Pattern;
  879.         thePort:                GrafPtr;
  880.     END;
  881.  
  882.     QDGlobalsPtr = ^QDGlobals;
  883.     QDGlobalsHdl = ^QDGlobalsPtr;
  884.  
  885.  
  886. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  887. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  888. VAR
  889.     {$PUSH}
  890.     {$J+}
  891.     qd: QDGlobals;
  892.     {$POP}
  893.  
  894. PROCEDURE InitGraf(globalPtr: UNIV Ptr);
  895.     {$IFC NOT GENERATINGCFM}
  896.     INLINE $A86E;
  897.     {$ENDC}
  898. PROCEDURE OpenPort(port: GrafPtr);
  899.     {$IFC NOT GENERATINGCFM}
  900.     INLINE $A86F;
  901.     {$ENDC}
  902. PROCEDURE InitPort(port: GrafPtr);
  903.     {$IFC NOT GENERATINGCFM}
  904.     INLINE $A86D;
  905.     {$ENDC}
  906. PROCEDURE ClosePort(port: GrafPtr);
  907.     {$IFC NOT GENERATINGCFM}
  908.     INLINE $A87D;
  909.     {$ENDC}
  910. PROCEDURE SetPort(port: GrafPtr);
  911.     {$IFC NOT GENERATINGCFM}
  912.     INLINE $A873;
  913.     {$ENDC}
  914. PROCEDURE GetPort(VAR port: GrafPtr);
  915.     {$IFC NOT GENERATINGCFM}
  916.     INLINE $A874;
  917.     {$ENDC}
  918. PROCEDURE GrafDevice(device: INTEGER);
  919.     {$IFC NOT GENERATINGCFM}
  920.     INLINE $A872;
  921.     {$ENDC}
  922. PROCEDURE SetPortBits({CONST}VAR bm: BitMap);
  923.     {$IFC NOT GENERATINGCFM}
  924.     INLINE $A875;
  925.     {$ENDC}
  926. PROCEDURE PortSize(width: INTEGER; height: INTEGER);
  927.     {$IFC NOT GENERATINGCFM}
  928.     INLINE $A876;
  929.     {$ENDC}
  930. PROCEDURE MovePortTo(leftGlobal: INTEGER; topGlobal: INTEGER);
  931.     {$IFC NOT GENERATINGCFM}
  932.     INLINE $A877;
  933.     {$ENDC}
  934. PROCEDURE SetOrigin(h: INTEGER; v: INTEGER);
  935.     {$IFC NOT GENERATINGCFM}
  936.     INLINE $A878;
  937.     {$ENDC}
  938. PROCEDURE SetClip(rgn: RgnHandle);
  939.     {$IFC NOT GENERATINGCFM}
  940.     INLINE $A879;
  941.     {$ENDC}
  942. PROCEDURE GetClip(rgn: RgnHandle);
  943.     {$IFC NOT GENERATINGCFM}
  944.     INLINE $A87A;
  945.     {$ENDC}
  946. PROCEDURE ClipRect({CONST}VAR r: Rect);
  947.     {$IFC NOT GENERATINGCFM}
  948.     INLINE $A87B;
  949.     {$ENDC}
  950. PROCEDURE BackPat({CONST}VAR pat: Pattern);
  951.     {$IFC NOT GENERATINGCFM}
  952.     INLINE $A87C;
  953.     {$ENDC}
  954. PROCEDURE InitCursor;
  955.     {$IFC NOT GENERATINGCFM}
  956.     INLINE $A850;
  957.     {$ENDC}
  958. PROCEDURE SetCursor({CONST}VAR crsr: Cursor);
  959.     {$IFC NOT GENERATINGCFM}
  960.     INLINE $A851;
  961.     {$ENDC}
  962. PROCEDURE HideCursor;
  963.     {$IFC NOT GENERATINGCFM}
  964.     INLINE $A852;
  965.     {$ENDC}
  966. PROCEDURE ShowCursor;
  967.     {$IFC NOT GENERATINGCFM}
  968.     INLINE $A853;
  969.     {$ENDC}
  970. PROCEDURE ObscureCursor;
  971.     {$IFC NOT GENERATINGCFM}
  972.     INLINE $A856;
  973.     {$ENDC}
  974. PROCEDURE HidePen;
  975.     {$IFC NOT GENERATINGCFM}
  976.     INLINE $A896;
  977.     {$ENDC}
  978. PROCEDURE ShowPen;
  979.     {$IFC NOT GENERATINGCFM}
  980.     INLINE $A897;
  981.     {$ENDC}
  982. PROCEDURE GetPen(VAR pt: Point);
  983.     {$IFC NOT GENERATINGCFM}
  984.     INLINE $A89A;
  985.     {$ENDC}
  986. PROCEDURE GetPenState(VAR pnState: PenState);
  987.     {$IFC NOT GENERATINGCFM}
  988.     INLINE $A898;
  989.     {$ENDC}
  990. PROCEDURE SetPenState({CONST}VAR pnState: PenState);
  991.     {$IFC NOT GENERATINGCFM}
  992.     INLINE $A899;
  993.     {$ENDC}
  994. PROCEDURE PenSize(width: INTEGER; height: INTEGER);
  995.     {$IFC NOT GENERATINGCFM}
  996.     INLINE $A89B;
  997.     {$ENDC}
  998. PROCEDURE PenMode(mode: INTEGER);
  999.     {$IFC NOT GENERATINGCFM}
  1000.     INLINE $A89C;
  1001.     {$ENDC}
  1002. PROCEDURE PenPat({CONST}VAR pat: Pattern);
  1003.     {$IFC NOT GENERATINGCFM}
  1004.     INLINE $A89D;
  1005.     {$ENDC}
  1006. PROCEDURE PenNormal;
  1007.     {$IFC NOT GENERATINGCFM}
  1008.     INLINE $A89E;
  1009.     {$ENDC}
  1010. PROCEDURE MoveTo(h: INTEGER; v: INTEGER);
  1011.     {$IFC NOT GENERATINGCFM}
  1012.     INLINE $A893;
  1013.     {$ENDC}
  1014. PROCEDURE Move(dh: INTEGER; dv: INTEGER);
  1015.     {$IFC NOT GENERATINGCFM}
  1016.     INLINE $A894;
  1017.     {$ENDC}
  1018. PROCEDURE LineTo(h: INTEGER; v: INTEGER);
  1019.     {$IFC NOT GENERATINGCFM}
  1020.     INLINE $A891;
  1021.     {$ENDC}
  1022. PROCEDURE Line(dh: INTEGER; dv: INTEGER);
  1023.     {$IFC NOT GENERATINGCFM}
  1024.     INLINE $A892;
  1025.     {$ENDC}
  1026. PROCEDURE ForeColor(color: LONGINT);
  1027.     {$IFC NOT GENERATINGCFM}
  1028.     INLINE $A862;
  1029.     {$ENDC}
  1030. PROCEDURE BackColor(color: LONGINT);
  1031.     {$IFC NOT GENERATINGCFM}
  1032.     INLINE $A863;
  1033.     {$ENDC}
  1034. PROCEDURE ColorBit(whichBit: INTEGER);
  1035.     {$IFC NOT GENERATINGCFM}
  1036.     INLINE $A864;
  1037.     {$ENDC}
  1038. PROCEDURE SetRect(VAR r: Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1039.     {$IFC NOT GENERATINGCFM}
  1040.     INLINE $A8A7;
  1041.     {$ENDC}
  1042. PROCEDURE OffsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1043.     {$IFC NOT GENERATINGCFM}
  1044.     INLINE $A8A8;
  1045.     {$ENDC}
  1046. PROCEDURE InsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1047.     {$IFC NOT GENERATINGCFM}
  1048.     INLINE $A8A9;
  1049.     {$ENDC}
  1050. FUNCTION SectRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect): BOOLEAN;
  1051.     {$IFC NOT GENERATINGCFM}
  1052.     INLINE $A8AA;
  1053.     {$ENDC}
  1054. PROCEDURE UnionRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect);
  1055.     {$IFC NOT GENERATINGCFM}
  1056.     INLINE $A8AB;
  1057.     {$ENDC}
  1058. FUNCTION EqualRect({CONST}VAR rect1: Rect; {CONST}VAR rect2: Rect): BOOLEAN;
  1059.     {$IFC NOT GENERATINGCFM}
  1060.     INLINE $A8A6;
  1061.     {$ENDC}
  1062. FUNCTION EmptyRect({CONST}VAR r: Rect): BOOLEAN;
  1063.     {$IFC NOT GENERATINGCFM}
  1064.     INLINE $A8AE;
  1065.     {$ENDC}
  1066. PROCEDURE FrameRect({CONST}VAR r: Rect);
  1067.     {$IFC NOT GENERATINGCFM}
  1068.     INLINE $A8A1;
  1069.     {$ENDC}
  1070. PROCEDURE PaintRect({CONST}VAR r: Rect);
  1071.     {$IFC NOT GENERATINGCFM}
  1072.     INLINE $A8A2;
  1073.     {$ENDC}
  1074. PROCEDURE EraseRect({CONST}VAR r: Rect);
  1075.     {$IFC NOT GENERATINGCFM}
  1076.     INLINE $A8A3;
  1077.     {$ENDC}
  1078. PROCEDURE InvertRect({CONST}VAR r: Rect);
  1079.     {$IFC NOT GENERATINGCFM}
  1080.     INLINE $A8A4;
  1081.     {$ENDC}
  1082. PROCEDURE FillRect({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1083.     {$IFC NOT GENERATINGCFM}
  1084.     INLINE $A8A5;
  1085.     {$ENDC}
  1086. PROCEDURE FrameOval({CONST}VAR r: Rect);
  1087.     {$IFC NOT GENERATINGCFM}
  1088.     INLINE $A8B7;
  1089.     {$ENDC}
  1090. PROCEDURE PaintOval({CONST}VAR r: Rect);
  1091.     {$IFC NOT GENERATINGCFM}
  1092.     INLINE $A8B8;
  1093.     {$ENDC}
  1094. PROCEDURE EraseOval({CONST}VAR r: Rect);
  1095.     {$IFC NOT GENERATINGCFM}
  1096.     INLINE $A8B9;
  1097.     {$ENDC}
  1098. PROCEDURE InvertOval({CONST}VAR r: Rect);
  1099.     {$IFC NOT GENERATINGCFM}
  1100.     INLINE $A8BA;
  1101.     {$ENDC}
  1102. PROCEDURE FillOval({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1103.     {$IFC NOT GENERATINGCFM}
  1104.     INLINE $A8BB;
  1105.     {$ENDC}
  1106. PROCEDURE FrameRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1107.     {$IFC NOT GENERATINGCFM}
  1108.     INLINE $A8B0;
  1109.     {$ENDC}
  1110. PROCEDURE PaintRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1111.     {$IFC NOT GENERATINGCFM}
  1112.     INLINE $A8B1;
  1113.     {$ENDC}
  1114. PROCEDURE EraseRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1115.     {$IFC NOT GENERATINGCFM}
  1116.     INLINE $A8B2;
  1117.     {$ENDC}
  1118. PROCEDURE InvertRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1119.     {$IFC NOT GENERATINGCFM}
  1120.     INLINE $A8B3;
  1121.     {$ENDC}
  1122. PROCEDURE FillRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; {CONST}VAR pat: Pattern);
  1123.     {$IFC NOT GENERATINGCFM}
  1124.     INLINE $A8B4;
  1125.     {$ENDC}
  1126. PROCEDURE FrameArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1127.     {$IFC NOT GENERATINGCFM}
  1128.     INLINE $A8BE;
  1129.     {$ENDC}
  1130. PROCEDURE PaintArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1131.     {$IFC NOT GENERATINGCFM}
  1132.     INLINE $A8BF;
  1133.     {$ENDC}
  1134. PROCEDURE EraseArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1135.     {$IFC NOT GENERATINGCFM}
  1136.     INLINE $A8C0;
  1137.     {$ENDC}
  1138. PROCEDURE InvertArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1139.     {$IFC NOT GENERATINGCFM}
  1140.     INLINE $A8C1;
  1141.     {$ENDC}
  1142. PROCEDURE FillArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; {CONST}VAR pat: Pattern);
  1143.     {$IFC NOT GENERATINGCFM}
  1144.     INLINE $A8C2;
  1145.     {$ENDC}
  1146. FUNCTION NewRgn: RgnHandle;
  1147.     {$IFC NOT GENERATINGCFM}
  1148.     INLINE $A8D8;
  1149.     {$ENDC}
  1150. PROCEDURE OpenRgn;
  1151.     {$IFC NOT GENERATINGCFM}
  1152.     INLINE $A8DA;
  1153.     {$ENDC}
  1154. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  1155.     {$IFC NOT GENERATINGCFM}
  1156.     INLINE $A8DB;
  1157.     {$ENDC}
  1158. {$IFC NOT SystemSevenOrLater }
  1159. FUNCTION BitMapToRegionGlue(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1160. {$ENDC}
  1161. FUNCTION BitMapToRegion(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1162.     {$IFC NOT GENERATINGCFM}
  1163.     INLINE $A8D7;
  1164.     {$ENDC}
  1165. PROCEDURE DisposeRgn(rgn: RgnHandle);
  1166.     {$IFC NOT GENERATINGCFM}
  1167.     INLINE $A8D9;
  1168.     {$ENDC}
  1169. PROCEDURE CopyRgn(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1170.     {$IFC NOT GENERATINGCFM}
  1171.     INLINE $A8DC;
  1172.     {$ENDC}
  1173. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  1174.     {$IFC NOT GENERATINGCFM}
  1175.     INLINE $A8DD;
  1176.     {$ENDC}
  1177. PROCEDURE SetRectRgn(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1178.     {$IFC NOT GENERATINGCFM}
  1179.     INLINE $A8DE;
  1180.     {$ENDC}
  1181. PROCEDURE RectRgn(rgn: RgnHandle; {CONST}VAR r: Rect);
  1182.     {$IFC NOT GENERATINGCFM}
  1183.     INLINE $A8DF;
  1184.     {$ENDC}
  1185. PROCEDURE OffsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1186.     {$IFC NOT GENERATINGCFM}
  1187.     INLINE $A8E0;
  1188.     {$ENDC}
  1189. PROCEDURE InsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1190.     {$IFC NOT GENERATINGCFM}
  1191.     INLINE $A8E1;
  1192.     {$ENDC}
  1193. PROCEDURE SectRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1194.     {$IFC NOT GENERATINGCFM}
  1195.     INLINE $A8E4;
  1196.     {$ENDC}
  1197. PROCEDURE UnionRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1198.     {$IFC NOT GENERATINGCFM}
  1199.     INLINE $A8E5;
  1200.     {$ENDC}
  1201. PROCEDURE DiffRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1202.     {$IFC NOT GENERATINGCFM}
  1203.     INLINE $A8E6;
  1204.     {$ENDC}
  1205. PROCEDURE XorRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1206.     {$IFC NOT GENERATINGCFM}
  1207.     INLINE $A8E7;
  1208.     {$ENDC}
  1209. FUNCTION RectInRgn({CONST}VAR r: Rect; rgn: RgnHandle): BOOLEAN;
  1210.     {$IFC NOT GENERATINGCFM}
  1211.     INLINE $A8E9;
  1212.     {$ENDC}
  1213. FUNCTION EqualRgn(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1214.     {$IFC NOT GENERATINGCFM}
  1215.     INLINE $A8E3;
  1216.     {$ENDC}
  1217. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  1218.     {$IFC NOT GENERATINGCFM}
  1219.     INLINE $A8E2;
  1220.     {$ENDC}
  1221. PROCEDURE FrameRgn(rgn: RgnHandle);
  1222.     {$IFC NOT GENERATINGCFM}
  1223.     INLINE $A8D2;
  1224.     {$ENDC}
  1225. PROCEDURE PaintRgn(rgn: RgnHandle);
  1226.     {$IFC NOT GENERATINGCFM}
  1227.     INLINE $A8D3;
  1228.     {$ENDC}
  1229. PROCEDURE EraseRgn(rgn: RgnHandle);
  1230.     {$IFC NOT GENERATINGCFM}
  1231.     INLINE $A8D4;
  1232.     {$ENDC}
  1233. PROCEDURE InvertRgn(rgn: RgnHandle);
  1234.     {$IFC NOT GENERATINGCFM}
  1235.     INLINE $A8D5;
  1236.     {$ENDC}
  1237. PROCEDURE FillRgn(rgn: RgnHandle; {CONST}VAR pat: Pattern);
  1238.     {$IFC NOT GENERATINGCFM}
  1239.     INLINE $A8D6;
  1240.     {$ENDC}
  1241. PROCEDURE ScrollRect({CONST}VAR r: Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1242.     {$IFC NOT GENERATINGCFM}
  1243.     INLINE $A8EF;
  1244.     {$ENDC}
  1245. PROCEDURE CopyBits({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1246.     {$IFC NOT GENERATINGCFM}
  1247.     INLINE $A8EC;
  1248.     {$ENDC}
  1249. PROCEDURE SeedFill(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1250.     {$IFC NOT GENERATINGCFM}
  1251.     INLINE $A839;
  1252.     {$ENDC}
  1253. PROCEDURE CalcMask(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1254.     {$IFC NOT GENERATINGCFM}
  1255.     INLINE $A838;
  1256.     {$ENDC}
  1257. PROCEDURE CopyMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect);
  1258.     {$IFC NOT GENERATINGCFM}
  1259.     INLINE $A817;
  1260.     {$ENDC}
  1261. FUNCTION OpenPicture({CONST}VAR picFrame: Rect): PicHandle;
  1262.     {$IFC NOT GENERATINGCFM}
  1263.     INLINE $A8F3;
  1264.     {$ENDC}
  1265. PROCEDURE PicComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1266.     {$IFC NOT GENERATINGCFM}
  1267.     INLINE $A8F2;
  1268.     {$ENDC}
  1269. PROCEDURE ClosePicture;
  1270.     {$IFC NOT GENERATINGCFM}
  1271.     INLINE $A8F4;
  1272.     {$ENDC}
  1273. PROCEDURE DrawPicture(myPicture: PicHandle; {CONST}VAR dstRect: Rect);
  1274.     {$IFC NOT GENERATINGCFM}
  1275.     INLINE $A8F6;
  1276.     {$ENDC}
  1277. PROCEDURE KillPicture(myPicture: PicHandle);
  1278.     {$IFC NOT GENERATINGCFM}
  1279.     INLINE $A8F5;
  1280.     {$ENDC}
  1281. FUNCTION OpenPoly: PolyHandle;
  1282.     {$IFC NOT GENERATINGCFM}
  1283.     INLINE $A8CB;
  1284.     {$ENDC}
  1285. PROCEDURE ClosePoly;
  1286.     {$IFC NOT GENERATINGCFM}
  1287.     INLINE $A8CC;
  1288.     {$ENDC}
  1289. PROCEDURE KillPoly(poly: PolyHandle);
  1290.     {$IFC NOT GENERATINGCFM}
  1291.     INLINE $A8CD;
  1292.     {$ENDC}
  1293. PROCEDURE OffsetPoly(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1294.     {$IFC NOT GENERATINGCFM}
  1295.     INLINE $A8CE;
  1296.     {$ENDC}
  1297. PROCEDURE FramePoly(poly: PolyHandle);
  1298.     {$IFC NOT GENERATINGCFM}
  1299.     INLINE $A8C6;
  1300.     {$ENDC}
  1301. PROCEDURE PaintPoly(poly: PolyHandle);
  1302.     {$IFC NOT GENERATINGCFM}
  1303.     INLINE $A8C7;
  1304.     {$ENDC}
  1305. PROCEDURE ErasePoly(poly: PolyHandle);
  1306.     {$IFC NOT GENERATINGCFM}
  1307.     INLINE $A8C8;
  1308.     {$ENDC}
  1309. PROCEDURE InvertPoly(poly: PolyHandle);
  1310.     {$IFC NOT GENERATINGCFM}
  1311.     INLINE $A8C9;
  1312.     {$ENDC}
  1313. PROCEDURE FillPoly(poly: PolyHandle; {CONST}VAR pat: Pattern);
  1314.     {$IFC NOT GENERATINGCFM}
  1315.     INLINE $A8CA;
  1316.     {$ENDC}
  1317. PROCEDURE SetPt(VAR pt: Point; h: INTEGER; v: INTEGER);
  1318.     {$IFC NOT GENERATINGCFM}
  1319.     INLINE $A880;
  1320.     {$ENDC}
  1321. PROCEDURE LocalToGlobal(VAR pt: Point);
  1322.     {$IFC NOT GENERATINGCFM}
  1323.     INLINE $A870;
  1324.     {$ENDC}
  1325. PROCEDURE GlobalToLocal(VAR pt: Point);
  1326.     {$IFC NOT GENERATINGCFM}
  1327.     INLINE $A871;
  1328.     {$ENDC}
  1329. FUNCTION Random: INTEGER;
  1330.     {$IFC NOT GENERATINGCFM}
  1331.     INLINE $A861;
  1332.     {$ENDC}
  1333. PROCEDURE StuffHex(thingPtr: UNIV Ptr; s: ConstStr255Param);
  1334.     {$IFC NOT GENERATINGCFM}
  1335.     INLINE $A866;
  1336.     {$ENDC}
  1337. FUNCTION GetPixel(h: INTEGER; v: INTEGER): BOOLEAN;
  1338.     {$IFC NOT GENERATINGCFM}
  1339.     INLINE $A865;
  1340.     {$ENDC}
  1341. PROCEDURE ScalePt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1342.     {$IFC NOT GENERATINGCFM}
  1343.     INLINE $A8F8;
  1344.     {$ENDC}
  1345. PROCEDURE MapPt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1346.     {$IFC NOT GENERATINGCFM}
  1347.     INLINE $A8F9;
  1348.     {$ENDC}
  1349. PROCEDURE MapRect(VAR r: Rect; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1350.     {$IFC NOT GENERATINGCFM}
  1351.     INLINE $A8FA;
  1352.     {$ENDC}
  1353. PROCEDURE MapRgn(rgn: RgnHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1354.     {$IFC NOT GENERATINGCFM}
  1355.     INLINE $A8FB;
  1356.     {$ENDC}
  1357. PROCEDURE MapPoly(poly: PolyHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1358.     {$IFC NOT GENERATINGCFM}
  1359.     INLINE $A8FC;
  1360.     {$ENDC}
  1361. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  1362.     {$IFC NOT GENERATINGCFM}
  1363.     INLINE $A8EA;
  1364.     {$ENDC}
  1365. PROCEDURE StdRect(verb: ByteParameter; {CONST}VAR r: Rect);
  1366.     {$IFC NOT GENERATINGCFM}
  1367.     INLINE $A8A0;
  1368.     {$ENDC}
  1369. PROCEDURE StdRRect(verb: ByteParameter; {CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1370.     {$IFC NOT GENERATINGCFM}
  1371.     INLINE $A8AF;
  1372.     {$ENDC}
  1373. PROCEDURE StdOval(verb: ByteParameter; {CONST}VAR r: Rect);
  1374.     {$IFC NOT GENERATINGCFM}
  1375.     INLINE $A8B6;
  1376.     {$ENDC}
  1377. PROCEDURE StdArc(verb: ByteParameter; {CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1378.     {$IFC NOT GENERATINGCFM}
  1379.     INLINE $A8BD;
  1380.     {$ENDC}
  1381. PROCEDURE StdPoly(verb: ByteParameter; poly: PolyHandle);
  1382.     {$IFC NOT GENERATINGCFM}
  1383.     INLINE $A8C5;
  1384.     {$ENDC}
  1385. PROCEDURE StdRgn(verb: ByteParameter; rgn: RgnHandle);
  1386.     {$IFC NOT GENERATINGCFM}
  1387.     INLINE $A8D1;
  1388.     {$ENDC}
  1389. PROCEDURE StdBits({CONST}VAR srcBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1390.     {$IFC NOT GENERATINGCFM}
  1391.     INLINE $A8EB;
  1392.     {$ENDC}
  1393. PROCEDURE StdComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1394.     {$IFC NOT GENERATINGCFM}
  1395.     INLINE $A8F1;
  1396.     {$ENDC}
  1397. PROCEDURE StdGetPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1398.     {$IFC NOT GENERATINGCFM}
  1399.     INLINE $A8EE;
  1400.     {$ENDC}
  1401. PROCEDURE StdPutPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1402.     {$IFC NOT GENERATINGCFM}
  1403.     INLINE $A8F0;
  1404.     {$ENDC}
  1405. PROCEDURE AddPt(src: Point; VAR dst: Point);
  1406.     {$IFC NOT GENERATINGCFM}
  1407.     INLINE $A87E;
  1408.     {$ENDC}
  1409. FUNCTION EqualPt(pt1: Point; pt2: Point): BOOLEAN;
  1410.     {$IFC NOT GENERATINGCFM}
  1411.     INLINE $A881;
  1412.     {$ENDC}
  1413. FUNCTION PtInRect(pt: Point; {CONST}VAR r: Rect): BOOLEAN;
  1414.     {$IFC NOT GENERATINGCFM}
  1415.     INLINE $A8AD;
  1416.     {$ENDC}
  1417. PROCEDURE Pt2Rect(pt1: Point; pt2: Point; VAR dstRect: Rect);
  1418.     {$IFC NOT GENERATINGCFM}
  1419.     INLINE $A8AC;
  1420.     {$ENDC}
  1421. PROCEDURE PtToAngle({CONST}VAR r: Rect; pt: Point; VAR angle: INTEGER);
  1422.     {$IFC NOT GENERATINGCFM}
  1423.     INLINE $A8C3;
  1424.     {$ENDC}
  1425. PROCEDURE SubPt(src: Point; VAR dst: Point);
  1426.     {$IFC NOT GENERATINGCFM}
  1427.     INLINE $A87F;
  1428.     {$ENDC}
  1429. FUNCTION PtInRgn(pt: Point; rgn: RgnHandle): BOOLEAN;
  1430.     {$IFC NOT GENERATINGCFM}
  1431.     INLINE $A8E8;
  1432.     {$ENDC}
  1433. PROCEDURE StdLine(newPt: Point);
  1434.     {$IFC NOT GENERATINGCFM}
  1435.     INLINE $A890;
  1436.     {$ENDC}
  1437. PROCEDURE OpenCPort(port: CGrafPtr);
  1438.     {$IFC NOT GENERATINGCFM}
  1439.     INLINE $AA00;
  1440.     {$ENDC}
  1441. PROCEDURE InitCPort(port: CGrafPtr);
  1442.     {$IFC NOT GENERATINGCFM}
  1443.     INLINE $AA01;
  1444.     {$ENDC}
  1445. PROCEDURE CloseCPort(port: CGrafPtr);
  1446.     {$IFC NOT GENERATINGCFM}
  1447.     INLINE $A87D;
  1448.     {$ENDC}
  1449. FUNCTION NewPixMap: PixMapHandle;
  1450.     {$IFC NOT GENERATINGCFM}
  1451.     INLINE $AA03;
  1452.     {$ENDC}
  1453. PROCEDURE DisposePixMap(pm: PixMapHandle);
  1454.     {$IFC NOT GENERATINGCFM}
  1455.     INLINE $AA04;
  1456.     {$ENDC}
  1457. PROCEDURE CopyPixMap(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1458.     {$IFC NOT GENERATINGCFM}
  1459.     INLINE $AA05;
  1460.     {$ENDC}
  1461. FUNCTION NewPixPat: PixPatHandle;
  1462.     {$IFC NOT GENERATINGCFM}
  1463.     INLINE $AA07;
  1464.     {$ENDC}
  1465. PROCEDURE DisposePixPat(pp: PixPatHandle);
  1466.     {$IFC NOT GENERATINGCFM}
  1467.     INLINE $AA08;
  1468.     {$ENDC}
  1469. PROCEDURE CopyPixPat(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1470.     {$IFC NOT GENERATINGCFM}
  1471.     INLINE $AA09;
  1472.     {$ENDC}
  1473. PROCEDURE PenPixPat(pp: PixPatHandle);
  1474.     {$IFC NOT GENERATINGCFM}
  1475.     INLINE $AA0A;
  1476.     {$ENDC}
  1477. PROCEDURE BackPixPat(pp: PixPatHandle);
  1478.     {$IFC NOT GENERATINGCFM}
  1479.     INLINE $AA0B;
  1480.     {$ENDC}
  1481. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  1482.     {$IFC NOT GENERATINGCFM}
  1483.     INLINE $AA0C;
  1484.     {$ENDC}
  1485. PROCEDURE MakeRGBPat(pp: PixPatHandle; {CONST}VAR myColor: RGBColor);
  1486.     {$IFC NOT GENERATINGCFM}
  1487.     INLINE $AA0D;
  1488.     {$ENDC}
  1489. PROCEDURE FillCRect({CONST}VAR r: Rect; pp: PixPatHandle);
  1490.     {$IFC NOT GENERATINGCFM}
  1491.     INLINE $AA0E;
  1492.     {$ENDC}
  1493. PROCEDURE FillCOval({CONST}VAR r: Rect; pp: PixPatHandle);
  1494.     {$IFC NOT GENERATINGCFM}
  1495.     INLINE $AA0F;
  1496.     {$ENDC}
  1497. PROCEDURE FillCRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1498.     {$IFC NOT GENERATINGCFM}
  1499.     INLINE $AA10;
  1500.     {$ENDC}
  1501. PROCEDURE FillCArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1502.     {$IFC NOT GENERATINGCFM}
  1503.     INLINE $AA11;
  1504.     {$ENDC}
  1505. PROCEDURE FillCRgn(rgn: RgnHandle; pp: PixPatHandle);
  1506.     {$IFC NOT GENERATINGCFM}
  1507.     INLINE $AA12;
  1508.     {$ENDC}
  1509. PROCEDURE FillCPoly(poly: PolyHandle; pp: PixPatHandle);
  1510.     {$IFC NOT GENERATINGCFM}
  1511.     INLINE $AA13;
  1512.     {$ENDC}
  1513. PROCEDURE RGBForeColor({CONST}VAR color: RGBColor);
  1514.     {$IFC NOT GENERATINGCFM}
  1515.     INLINE $AA14;
  1516.     {$ENDC}
  1517. PROCEDURE RGBBackColor({CONST}VAR color: RGBColor);
  1518.     {$IFC NOT GENERATINGCFM}
  1519.     INLINE $AA15;
  1520.     {$ENDC}
  1521. PROCEDURE SetCPixel(h: INTEGER; v: INTEGER; {CONST}VAR cPix: RGBColor);
  1522.     {$IFC NOT GENERATINGCFM}
  1523.     INLINE $AA16;
  1524.     {$ENDC}
  1525. PROCEDURE SetPortPix(pm: PixMapHandle);
  1526.     {$IFC NOT GENERATINGCFM}
  1527.     INLINE $AA06;
  1528.     {$ENDC}
  1529. PROCEDURE GetCPixel(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1530.     {$IFC NOT GENERATINGCFM}
  1531.     INLINE $AA17;
  1532.     {$ENDC}
  1533. PROCEDURE GetForeColor(VAR color: RGBColor);
  1534.     {$IFC NOT GENERATINGCFM}
  1535.     INLINE $AA19;
  1536.     {$ENDC}
  1537. PROCEDURE GetBackColor(VAR color: RGBColor);
  1538.     {$IFC NOT GENERATINGCFM}
  1539.     INLINE $AA1A;
  1540.     {$ENDC}
  1541. PROCEDURE SeedCFill({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1542.     {$IFC NOT GENERATINGCFM}
  1543.     INLINE $AA50;
  1544.     {$ENDC}
  1545. PROCEDURE CalcCMask({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; {CONST}VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1546.     {$IFC NOT GENERATINGCFM}
  1547.     INLINE $AA4F;
  1548.     {$ENDC}
  1549. FUNCTION OpenCPicture({CONST}VAR newHeader: OpenCPicParams): PicHandle;
  1550.     {$IFC NOT GENERATINGCFM}
  1551.     INLINE $AA20;
  1552.     {$ENDC}
  1553. PROCEDURE OpColor({CONST}VAR color: RGBColor);
  1554.     {$IFC NOT GENERATINGCFM}
  1555.     INLINE $AA21;
  1556.     {$ENDC}
  1557. PROCEDURE HiliteColor({CONST}VAR color: RGBColor);
  1558.     {$IFC NOT GENERATINGCFM}
  1559.     INLINE $AA22;
  1560.     {$ENDC}
  1561. PROCEDURE DisposeCTable(cTable: CTabHandle);
  1562.     {$IFC NOT GENERATINGCFM}
  1563.     INLINE $AA24;
  1564.     {$ENDC}
  1565. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  1566.     {$IFC NOT GENERATINGCFM}
  1567.     INLINE $AA18;
  1568.     {$ENDC}
  1569. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  1570.     {$IFC NOT GENERATINGCFM}
  1571.     INLINE $AA1B;
  1572.     {$ENDC}
  1573. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  1574.     {$IFC NOT GENERATINGCFM}
  1575.     INLINE $AA1C;
  1576.     {$ENDC}
  1577. PROCEDURE AllocCursor;
  1578.     {$IFC NOT GENERATINGCFM}
  1579.     INLINE $AA1D;
  1580.     {$ENDC}
  1581. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  1582.     {$IFC NOT GENERATINGCFM}
  1583.     INLINE $AA26;
  1584.     {$ENDC}
  1585. {$IFC OLDROUTINELOCATIONS }
  1586. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  1587.     {$IFC NOT GENERATINGCFM}
  1588.     INLINE $AA1E;
  1589.     {$ENDC}
  1590. PROCEDURE PlotCIcon({CONST}VAR theRect: Rect; theIcon: CIconHandle);
  1591.     {$IFC NOT GENERATINGCFM}
  1592.     INLINE $AA1F;
  1593.     {$ENDC}
  1594. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  1595.     {$IFC NOT GENERATINGCFM}
  1596.     INLINE $AA25;
  1597.     {$ENDC}
  1598. {$ENDC}
  1599. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  1600.     {$IFC NOT GENERATINGCFM}
  1601.     INLINE $AA4E;
  1602.     {$ENDC}
  1603. FUNCTION GetMaxDevice({CONST}VAR globalRect: Rect): GDHandle;
  1604.     {$IFC NOT GENERATINGCFM}
  1605.     INLINE $AA27;
  1606.     {$ENDC}
  1607. FUNCTION GetCTSeed: LONGINT;
  1608.     {$IFC NOT GENERATINGCFM}
  1609.     INLINE $AA28;
  1610.     {$ENDC}
  1611. FUNCTION GetDeviceList: GDHandle;
  1612.     {$IFC NOT GENERATINGCFM}
  1613.     INLINE $AA29;
  1614.     {$ENDC}
  1615. FUNCTION GetMainDevice: GDHandle;
  1616.     {$IFC NOT GENERATINGCFM}
  1617.     INLINE $AA2A;
  1618.     {$ENDC}
  1619. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  1620.     {$IFC NOT GENERATINGCFM}
  1621.     INLINE $AA2B;
  1622.     {$ENDC}
  1623. FUNCTION TestDeviceAttribute(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1624.     {$IFC NOT GENERATINGCFM}
  1625.     INLINE $AA2C;
  1626.     {$ENDC}
  1627. PROCEDURE SetDeviceAttribute(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1628.     {$IFC NOT GENERATINGCFM}
  1629.     INLINE $AA2D;
  1630.     {$ENDC}
  1631. PROCEDURE InitGDevice(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1632.     {$IFC NOT GENERATINGCFM}
  1633.     INLINE $AA2E;
  1634.     {$ENDC}
  1635. FUNCTION NewGDevice(refNum: INTEGER; mode: LONGINT): GDHandle;
  1636.     {$IFC NOT GENERATINGCFM}
  1637.     INLINE $AA2F;
  1638.     {$ENDC}
  1639. PROCEDURE DisposeGDevice(gdh: GDHandle);
  1640.     {$IFC NOT GENERATINGCFM}
  1641.     INLINE $AA30;
  1642.     {$ENDC}
  1643. PROCEDURE SetGDevice(gd: GDHandle);
  1644.     {$IFC NOT GENERATINGCFM}
  1645.     INLINE $AA31;
  1646.     {$ENDC}
  1647. FUNCTION GetGDevice: GDHandle;
  1648.     {$IFC NOT GENERATINGCFM}
  1649.     INLINE $AA32;
  1650.     {$ENDC}
  1651. FUNCTION Color2Index({CONST}VAR myColor: RGBColor): LONGINT;
  1652.     {$IFC NOT GENERATINGCFM}
  1653.     INLINE $AA33;
  1654.     {$ENDC}
  1655. PROCEDURE Index2Color(index: LONGINT; VAR aColor: RGBColor);
  1656.     {$IFC NOT GENERATINGCFM}
  1657.     INLINE $AA34;
  1658.     {$ENDC}
  1659. PROCEDURE InvertColor(VAR myColor: RGBColor);
  1660.     {$IFC NOT GENERATINGCFM}
  1661.     INLINE $AA35;
  1662.     {$ENDC}
  1663. FUNCTION RealColor({CONST}VAR color: RGBColor): BOOLEAN;
  1664.     {$IFC NOT GENERATINGCFM}
  1665.     INLINE $AA36;
  1666.     {$ENDC}
  1667. PROCEDURE GetSubTable(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1668.     {$IFC NOT GENERATINGCFM}
  1669.     INLINE $AA37;
  1670.     {$ENDC}
  1671. PROCEDURE MakeITable(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1672.     {$IFC NOT GENERATINGCFM}
  1673.     INLINE $AA39;
  1674.     {$ENDC}
  1675. PROCEDURE AddSearch(searchProc: ColorSearchUPP);
  1676.     {$IFC NOT GENERATINGCFM}
  1677.     INLINE $AA3A;
  1678.     {$ENDC}
  1679. PROCEDURE AddComp(compProc: ColorComplementUPP);
  1680.     {$IFC NOT GENERATINGCFM}
  1681.     INLINE $AA3B;
  1682.     {$ENDC}
  1683. PROCEDURE DelSearch(searchProc: ColorSearchUPP);
  1684.     {$IFC NOT GENERATINGCFM}
  1685.     INLINE $AA4C;
  1686.     {$ENDC}
  1687. PROCEDURE DelComp(compProc: ColorComplementUPP);
  1688.     {$IFC NOT GENERATINGCFM}
  1689.     INLINE $AA4D;
  1690.     {$ENDC}
  1691. PROCEDURE SetClientID(id: INTEGER);
  1692.     {$IFC NOT GENERATINGCFM}
  1693.     INLINE $AA3C;
  1694.     {$ENDC}
  1695. PROCEDURE ProtectEntry(index: INTEGER; protect: BOOLEAN);
  1696.     {$IFC NOT GENERATINGCFM}
  1697.     INLINE $AA3D;
  1698.     {$ENDC}
  1699. PROCEDURE ReserveEntry(index: INTEGER; reserve: BOOLEAN);
  1700.     {$IFC NOT GENERATINGCFM}
  1701.     INLINE $AA3E;
  1702.     {$ENDC}
  1703. PROCEDURE SetEntries(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1704.     {$IFC NOT GENERATINGCFM}
  1705.     INLINE $AA3F;
  1706.     {$ENDC}
  1707. PROCEDURE SaveEntries(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1708.     {$IFC NOT GENERATINGCFM}
  1709.     INLINE $AA49;
  1710.     {$ENDC}
  1711. PROCEDURE RestoreEntries(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1712.     {$IFC NOT GENERATINGCFM}
  1713.     INLINE $AA4A;
  1714.     {$ENDC}
  1715. FUNCTION QDError: INTEGER;
  1716.     {$IFC NOT GENERATINGCFM}
  1717.     INLINE $AA40;
  1718.     {$ENDC}
  1719. PROCEDURE CopyDeepMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1720.     {$IFC NOT GENERATINGCFM}
  1721.     INLINE $AA51;
  1722.     {$ENDC}
  1723. PROCEDURE DeviceLoop(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1724.     {$IFC NOT GENERATINGCFM}
  1725.     INLINE $ABCA;
  1726.     {$ENDC}
  1727. FUNCTION GetMaskTable: Ptr;
  1728.     {$IFC NOT GENERATINGCFM}
  1729.     INLINE $A836, $2E88;
  1730.     {$ENDC}
  1731. {$IFC OLDROUTINENAMES }
  1732. PROCEDURE DisposPixMap(pm: PixMapHandle);
  1733.     {$IFC NOT GENERATINGCFM}
  1734.     INLINE $AA04;
  1735.     {$ENDC}
  1736. PROCEDURE DisposPixPat(pp: PixPatHandle);
  1737.     {$IFC NOT GENERATINGCFM}
  1738.     INLINE $AA08;
  1739.     {$ENDC}
  1740. PROCEDURE DisposCTable(cTable: CTabHandle);
  1741.     {$IFC NOT GENERATINGCFM}
  1742.     INLINE $AA24;
  1743.     {$ENDC}
  1744. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  1745.     {$IFC NOT GENERATINGCFM}
  1746.     INLINE $AA26;
  1747.     {$ENDC}
  1748. {$IFC OLDROUTINELOCATIONS }
  1749. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  1750.     {$IFC NOT GENERATINGCFM}
  1751.     INLINE $AA25;
  1752.     {$ENDC}
  1753. {$ENDC}
  1754. PROCEDURE DisposGDevice(gdh: GDHandle);
  1755.     {$IFC NOT GENERATINGCFM}
  1756.     INLINE $AA30;
  1757.     {$ENDC}
  1758. {$ENDC}
  1759.  
  1760. {$ALIGN RESET}
  1761. {$POP}
  1762.  
  1763. {$SETC UsingIncludes := QuickdrawIncludes}
  1764.  
  1765. {$ENDC} {__QUICKDRAW__}
  1766.  
  1767. {$IFC NOT UsingIncludes}
  1768.  END.
  1769. {$ENDC}
  1770.